home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / cgad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  53.6 KB  |  2,268 lines
  1. /* GadTools-Gadgets */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase         *SysBase;
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6.  
  7. void Redraw();
  8. void AddHook();
  9. void ChangeListviewEntryNumber();
  10.  
  11. /* ---- GadTools-Gadget initialisieren */
  12. struct MWGadget *InitGTGadget(gadgetID,helpID,kind,x,y,w,h,textID,flags,extSize)
  13.  ULONG          gadgetID;
  14.  ULONG          helpID;
  15.  UWORD          kind;
  16.  UWORD          x,y,w,h;
  17.  ULONG          textID;
  18.  ULONG          flags;
  19.  ULONG          extSize;
  20. {
  21.  struct MultiWindowsUser *mw;
  22.  struct MWGadget         *gad;
  23.  int                      i;
  24.  struct WindowEntry      *we;
  25.  
  26.  USER;
  27.  WE;
  28.  if(we==NULL) return(NULL);
  29.  
  30.  gad=ALLOC2(sizeof(struct MWGadget)+extSize);
  31.  if(gad==NULL) return(NULL);
  32.  if(extSize) gad->ExtData=(ULONG)gad+(ULONG)sizeof(struct MWGadget);
  33.  
  34.  for(i=1;i<MWGADGET_TAGS;i++) gad->TagList[i].ti_Tag=TAG_DONE;
  35.  
  36.  gad->WindowEntry=we;
  37.  gad->GadgetID=gadgetID;
  38.  gad->HelpID=helpID;
  39.  gad->Type=MWGAD_GADTOOLS;
  40.  gad->Kind=kind;
  41.  gad->LeftEdge=x;
  42.  gad->TopEdge=y;
  43.  gad->Width=w;
  44.  gad->Height=h;
  45.  gad->NewGadget.ng_LeftEdge=INewX(we,x);
  46.  gad->NewGadget.ng_TopEdge=INewY(we,y);
  47.  gad->NewGadget.ng_Width=INewWidth(we,w);
  48.  gad->NewGadget.ng_Height=INewHeight(we,h);
  49.  gad->NewGadget.ng_GadgetText=FindID(mw->Catalog,textID);
  50.  gad->NewGadget.ng_VisualInfo=we->VisualInfo;
  51.  gad->NewGadget.ng_TextAttr=mw->TextAttr;
  52.  gad->NewGadget.ng_Flags=flags;
  53.  gad->NewGadget.ng_UserData=gad;
  54.  gad->TagList[GADGET_UNDERSCORE].ti_Tag=GT_Underscore;
  55.  gad->TagList[GADGET_UNDERSCORE].ti_Data='_';
  56.  gad->TagList[GADGET_DISABLE].ti_Tag=GA_Disabled;
  57.  return(gad);
  58. }
  59.  
  60. /* --- Gadget-Bereich löschen (wg. Wallpaper) */
  61. void ClearGad(we,gad)
  62.  struct WindowEntry *we;
  63.  struct MWGadget    *gad;
  64. {
  65.  UWORD                x1,y1,x2,y2;
  66.  struct ListViewData *ld;
  67.  
  68.  if(we->Wallpaper)
  69.   {
  70.    ld=NULL;
  71.    if(gad->Type==MWGAD_GADTOOLS)
  72.     {
  73.      switch(gad->Kind)
  74.       {
  75.        case PALETTE_KIND:
  76.        case MX_KIND:
  77.          return;
  78.         break;
  79.        case LISTVIEW_KIND:
  80.          ld=gad->ExtData;
  81.         break;
  82.       }
  83.     }
  84.  
  85.    if(ld)
  86.     {
  87.      x1=ld->X1;
  88.      x2=ld->X2-1;
  89.      y1=ld->Y1;
  90.      y2=ld->Y2-1;
  91.     }
  92.    else
  93.     {
  94.      x1=gad->NewGadget.ng_LeftEdge;
  95.      y1=gad->NewGadget.ng_TopEdge;
  96.      x2=gad->NewGadget.ng_LeftEdge+gad->NewGadget.ng_Width;
  97.      y2=gad->NewGadget.ng_TopEdge+gad->NewGadget.ng_Height-1;
  98.     }
  99.  
  100.    BackupRP(we);
  101.    SetAPen(we->RastPort,0);
  102.    RectFill(we->RastPort,x1,y1,x2,y2);
  103.    RestoreRP(we);
  104.   }
  105. }
  106.  
  107. /* ---- MultiWindows-Gadget erstellen */
  108. BOOL AddMWGadget(gad)
  109.  struct MWGadget *gad;
  110. {
  111.  UBYTE                   *title;
  112.  struct MultiWindowsUser *mw;
  113.  struct WindowEntry      *we;
  114.  int                      i,j;
  115.  
  116.  USER;
  117.  WE;
  118.  if(we==NULL) return(FALSE);
  119.  
  120.  if(gad->Type==MWGAD_GADTOOLS)
  121.   {
  122.    gad->Gadget=CreateContext(&gad->Gadget);
  123.    if(gad->Gadget==NULL)
  124.     {
  125.      FREE2(gad);
  126.      NoMemory();
  127.      return(FALSE);
  128.     }
  129.  
  130.    gad->Update=CreateGadgetA(gad->Kind,gad->Gadget,&gad->NewGadget,&gad->TagList);
  131.    if(gad->Update==NULL)
  132.     {
  133.      GadErr(1008,"AddMWGadget():\nGadTools CreateGadgetA() error!",gad);
  134.      FreeGadgets(gad->Gadget);
  135.      FREE2(gad);
  136.      return(FALSE);
  137.     }
  138.  
  139.    switch(gad->Kind)
  140.     {
  141.      case BUTTON_KIND:
  142.        if(gad->ExtData==TOGGLE_MAGIC)
  143.         {
  144.          gad->Update->Activation |= TOGGLESELECT;
  145.          if(gad->TagList[TOGGLE_STATUS].ti_Data==TRUE)
  146.            gad->Update->Flags |= SELECTED;
  147.         }
  148.       break;
  149.      case MX_KIND:
  150.        if(gad->TagList[GADGET_DISABLE].ti_Data) DisableGad(gad->Gadget);
  151.        MXResize(we,gad);
  152.       break;
  153.      case LISTVIEW_KIND:
  154.        LVResize(we,gad);
  155.       break;
  156.      case INTEGER_KIND:
  157.        if(gad->Update->GadgetText)
  158.          gad->Update->GadgetText->ITextFont=mw->TextAttr;
  159.       break;
  160.      case STRING_KIND:
  161.        if(gad->Update->GadgetText)
  162.          gad->Update->GadgetText->ITextFont=mw->TextAttr;
  163.        AddHook(gad);
  164.       break;
  165.     }
  166.  
  167.    if(!we->Iconify)
  168.      ClearGad(we,gad);
  169.    gad->Gadget->UserData=gad;
  170.   }
  171.  
  172.  title=gad->NewGadget.ng_GadgetText;
  173.  if(title)
  174.   {
  175.    j=strlen(title);
  176.    for(i=0;i<j;i++)
  177.     {
  178.      if(title[i]=='_')
  179.       {
  180.        gad->CommandKey=toupper(title[i+1]); break;
  181.       }
  182.     }
  183.   }
  184.  
  185.  AddTail(&we->GadgetList,gad);
  186.  if(!we->Iconify)
  187.   {
  188.    if(gad->Gadget)
  189.     {
  190.      gad->GadgetCount=CountGadgets(gad->Gadget);
  191.      AddGList(we->Window,gad->Gadget,0,-1L,NULL);
  192.      RefreshGList(gad->Gadget,we->Window,NULL,gad->GadgetCount);
  193.      GTRefreshWindow(we->Window,NULL);
  194.     }
  195.   }
  196.  we->LastGadget=gad;
  197.  
  198.  return(TRUE);
  199. }
  200.  
  201. /* ---- Gadget suchen */
  202. struct MWGadget *FindGadget(gadgetID)
  203.  ULONG gadgetID;
  204. {
  205.  struct Node        *node;
  206.  struct MWGadget    *gad;
  207.  struct WindowEntry *we;
  208.  
  209.  WE;
  210.  if(we==NULL) return(FALSE);
  211.  
  212.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  213.   {
  214.    gad=node;
  215.    if(gad->GadgetID==gadgetID) return(gad);
  216.   }
  217.  return(NULL);
  218. }
  219.  
  220. /* ---- Gadget disabled */
  221. void DisableGadget(gadgetID)
  222.  ULONG gadgetID;
  223. {
  224.  struct MWGadget     *gad;
  225.  struct WindowEntry  *we;
  226.  struct Gadget       *g;
  227.  int                  i;
  228.  
  229.  WE;
  230.  if(we==NULL) return;
  231.  
  232.  gad=FindGadget(gadgetID);
  233.  if(gad)
  234.   {
  235.    if((gad->Type==MWGAD_GADTOOLS)&&(gad->Kind==LISTVIEW_KIND)) return;
  236.    if(gad->TagList[GADGET_DISABLE].ti_Data==TRUE) return;
  237.    gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  238.  
  239.    if(gad->Gadget)
  240.     {
  241.      g=gad->Gadget;
  242.      for(i=0;i<gad->GadgetCount;i++)
  243.       {
  244.        g->Flags |= GADGDISABLED;
  245.        g=g->NextGadget;
  246.       }
  247.      RefreshGList(gad->Gadget,we->Window,NULL,gad->GadgetCount);
  248.     }
  249.    if(gad->Type==MWGAD_SPECIAL)
  250.      RefreshSGadget(gad);
  251.   }
  252. }
  253.  
  254. /* ---- Gadget enablen */
  255. void EnableGadget(gadgetID)
  256.  ULONG gadgetID;
  257. {
  258.  struct MWGadget     *gad;
  259.  struct WindowEntry  *we;
  260.  struct Gadget       *g;
  261.  int                  i;
  262.  
  263.  WE;
  264.  if(we==NULL) return;
  265.  
  266.  gad=FindGadget(gadgetID);
  267.  if(gad)
  268.   {
  269.    if((gad->Type==MWGAD_GADTOOLS)&&(gad->Kind==LISTVIEW_KIND)) return;
  270.    if(gad->TagList[GADGET_DISABLE].ti_Data==FALSE) return;
  271.    gad->TagList[GADGET_DISABLE].ti_Data=FALSE;
  272.  
  273.    if(gad->Gadget)
  274.     {
  275.      g=gad->Gadget;
  276.      for(i=0;i<gad->GadgetCount;i++)
  277.       {
  278.        g->Flags &= ~GADGDISABLED;
  279.        g=g->NextGadget;
  280.       }
  281.      RefreshGList(gad->Gadget,we->Window,NULL,gad->GadgetCount);
  282.     }
  283.    if(gad->Type==MWGAD_SPECIAL)
  284.      RefreshSGadget(gad);
  285.   }
  286. }
  287.  
  288. /* ---- Mehrere Gadgets disablen */
  289. void DisableGadgetArray(array)
  290.  ULONG *array;
  291. {
  292.  int i;
  293.  
  294.  i=0;
  295.  while(array[i]!=0)
  296.   {
  297.    DisableGadget(array[i]);
  298.    i++;
  299.    if(i>500) break;
  300.   }
  301. }
  302.  
  303. /* ---- Mehrere Gadgets enablen */
  304. void EnableGadgetArray(array)
  305.  ULONG *array;
  306. {
  307.  int i;
  308.  
  309.  i=0;
  310.  while(array[i]!=0)
  311.   {
  312.    EnableGadget(array[i]);
  313.    i++;
  314.    if(i>500) break;
  315.   }
  316. }
  317.  
  318. /* ---- Gadget entfernen */
  319. void RemGadget(gadgetID)
  320.  ULONG gadgetID;
  321. {
  322.  struct MWGadget     *gad;
  323.  struct WindowEntry  *we;
  324.  struct ListviewData *ld;
  325.  struct IconData     *iconData;
  326.  struct ImageData    *imageData;
  327.  
  328.  WE;
  329.  if(we==NULL) return;
  330.  
  331.  gad=FindGadget(gadgetID);
  332.  if(gad)
  333.   {
  334.    Remove(gad);
  335.    if(gad==we->LastGadget) we->LastGadget=NULL;
  336.  
  337.    if(!we->Iconify)
  338.     {
  339.      if(gad->Gadget) RemoveGList(we->Window,gad->Gadget,gad->GadgetCount);
  340.      RemGad(we,gad);
  341.     }
  342.  
  343.    switch(gad->Type)
  344.     {
  345.      case MWGAD_GADTOOLS:
  346.        if(gad->Gadget) FreeGList(gad->Gadget,gad->GadgetCount);
  347.        if(gad->Kind==LISTVIEW_KIND)
  348.         {
  349.          ld=gad->ExtData;
  350.          FreeMemory(&ld->Remember);
  351.         }
  352.       break;
  353.      case MWGAD_SPECIAL:
  354.        switch(gad->Kind)
  355.         {
  356.          case ICON_KIND:
  357.            iconData=gad->ExtData;
  358.            if(iconData->Icon) FreeDiskObject(iconData->Icon);
  359.           break;
  360.          case IMAGE_KIND:
  361.            imageData=gad->ExtData;
  362.            if(imageData->Image) DisposeObject(imageData->Image);
  363.           break;
  364.         }
  365.       break;
  366.     }
  367.    FreeMemory(&gad->Remember);
  368.    FREE2(gad);
  369.   }
  370. }
  371.  
  372. /* ---- Gadgets neuzeichnen */
  373. void Redraw()
  374. {
  375.  struct WindowEntry *we;
  376.  
  377.  WE;
  378.  if(we==NULL) return;
  379.  if(we->Iconify) return;
  380.  
  381.  RefreshSGadgets(we);
  382.  if(we->Window->FirstGadget)
  383.    RefreshGList(we->Window->FirstGadget,we->Window,NULL,-1L);
  384.  GTRefreshWindow(we->Window,NULL);
  385.  RefreshWindowFrame(we->Window);
  386. }
  387.  
  388. /* ---- Button-Gadget erstellen */
  389. BOOL AddButton(gadgetID,helpID,x,y,w,h,textID,flags)
  390.  ULONG          gadgetID;
  391.  ULONG          helpID;
  392.  UWORD          x,y,w,h;
  393.  ULONG          textID;
  394.  UWORD          flags;
  395. {
  396.  struct MWGadget         *gad;
  397.  struct WindowEntry      *we;
  398.  
  399.  WE;
  400.  if(we==NULL) return(FALSE);
  401.  
  402.  gad=InitGTGadget(gadgetID,helpID,BUTTON_KIND,x,y,w,h,textID,PLACETEXT_IN,0L);
  403.  if(gad==NULL) { NoMemory(); return(FALSE); }
  404.  
  405.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  406.  
  407.  return(AddMWGadget(gad));
  408. }
  409.  
  410. /* ---- Toggle-Gadget erstellen */
  411. BOOL AddToggle(gadgetID,helpID,x,y,w,h,textID,flags,selected)
  412.  ULONG          gadgetID;
  413.  ULONG          helpID;
  414.  UWORD          x,y,w,h;
  415.  ULONG          textID;
  416.  UWORD          flags;
  417. {
  418.  struct MWGadget         *gad;
  419.  struct WindowEntry      *we;
  420.  
  421.  WE;
  422.  if(we==NULL) return(FALSE);
  423.  
  424.  gad=InitGTGadget(gadgetID,helpID,BUTTON_KIND,x,y,w,h,textID,PLACETEXT_IN,0L);
  425.  if(gad==NULL) { NoMemory(); return(FALSE); }
  426.  
  427.  gad->ExtData=TOGGLE_MAGIC;
  428.  
  429.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  430.  gad->TagList[TOGGLE_STATUS].ti_Data=selected;
  431.  
  432.  return(AddMWGadget(gad));
  433. }
  434.  
  435. /* ---- Cycle-Gadget erstellen */
  436. BOOL AddCycle(gadgetID,helpID,x,y,w,h,textID,flags,labels,active)
  437.  ULONG          gadgetID;
  438.  ULONG          helpID;
  439.  UWORD          x,y,w,h;
  440.  ULONG          textID;
  441.  UWORD           flags;
  442.  ULONG         *labels;
  443.  UBYTE          active;
  444. {
  445.  struct MWGadget         *gad;
  446.  struct WindowEntry      *we;
  447.  struct MultiWindowsUser *mw;
  448.  struct CycleData        *cd;
  449.  int                      i;
  450.  
  451.  USER;
  452.  WE;
  453.  if(we==NULL) return(FALSE);
  454.  
  455.  gad=InitGTGadget(gadgetID,helpID,CYCLE_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  456.  if(gad==NULL) { NoMemory(); return(FALSE); }
  457.  
  458.  cd=gad->ExtData;
  459.  for(i=0;i<12;i++)
  460.   {
  461.    if(labels[i]==0) break;
  462.    cd->Labels[i]=FindID(mw->Catalog,labels[i]);
  463.    cd->LabelCount++;
  464.   }
  465.  cd->Labels[12]=0L;
  466.  
  467.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  468.  gad->TagList[CYCLE_LABELS].ti_Tag=GTCY_Labels;
  469.  gad->TagList[CYCLE_LABELS].ti_Data=&cd->Labels;
  470.  gad->TagList[CYCLE_ACTIVE].ti_Tag=GTCY_Active;
  471.  gad->TagList[CYCLE_ACTIVE].ti_Data=active;
  472.  
  473.  return(AddMWGadget(gad));
  474. }
  475.  
  476. /* ---- Toggle-Gadget abfragen */
  477. BOOL AskToggle(gadgetID)
  478.  ULONG gadgetID;
  479. {
  480.  struct MWGadget *gad;
  481.  
  482.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,BUTTON_KIND);
  483.  if((gad)&&(gad->ExtData==TOGGLE_MAGIC))
  484.    return((BOOL)gad->TagList[TOGGLE_STATUS].ti_Data);
  485.  return(FALSE);
  486. }
  487.  
  488. /* ---- Toggle-Gadget updaten */
  489. void UpdateToggle(gadgetID,selected)
  490.  ULONG gadgetID;
  491.  BOOL  selected;
  492. {
  493.  struct MWGadget    *gad;
  494.  struct WindowEntry *we;
  495.  struct CycleData   *cd;
  496.  
  497.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,BUTTON_KIND);
  498.  if((gad)&&(gad->ExtData==TOGGLE_MAGIC))
  499.   {
  500.    we=gad->WindowEntry;
  501.    gad->TagList[TOGGLE_STATUS].ti_Data=selected;
  502.    if(selected)
  503.      gad->Update->Flags |= SELECTED;
  504.    else
  505.      gad->Update->Flags &= ~SELECTED;
  506.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  507.   }
  508. }
  509.  
  510. /* ---- Cycle-Gadget updaten */
  511. void UpdateCycle(gadgetID,active)
  512.  ULONG gadgetID;
  513.  UBYTE active;
  514. {
  515.  struct MWGadget    *gad;
  516.  struct WindowEntry *we;
  517.  struct CycleData   *cd;
  518.  
  519.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,CYCLE_KIND);
  520.  if(gad)
  521.   {
  522.    we=gad->WindowEntry;
  523.    cd=gad->ExtData;
  524.    if(cd->LabelCount==0) return;
  525.    if(active>=cd->LabelCount) active=cd->LabelCount-1;
  526.    gad->TagList[CYCLE_ACTIVE].ti_Data=active;
  527.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  528.   }
  529. }
  530.  
  531. /* ---- Auswahl des Cycle-Gadget ermitteln */
  532. WORD AskCycle(gadgetID)
  533.  ULONG gadgetID;
  534. {
  535.  struct MWGadget *gad;
  536.  
  537.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,CYCLE_KIND);
  538.  if(gad)
  539.    return((WORD)gad->TagList[CYCLE_ACTIVE].ti_Data);
  540.  return(-1);
  541. }
  542.  
  543. /* ---- Cycle-Gadget erstellen */
  544. BOOL AddListview(gadgetID,helpID,x,y,w,h,textID,flags,labels,selected)
  545.  ULONG          gadgetID;
  546.  ULONG          helpID;
  547.  UWORD          x,y,w,h;
  548.  ULONG          textID;
  549.  ULONG          flags;
  550.  ULONG         *labels;
  551.  UBYTE          selected;
  552. {
  553.  struct MWGadget         *gad;
  554.  struct WindowEntry      *we;
  555.  struct MultiWindowsUser *mw;
  556.  struct ListviewData     *ld;
  557.  struct ListviewNode     *ln;
  558.  int                      i,j;
  559.  
  560.  USER;
  561.  WE;
  562.  if(we==NULL) return(FALSE);
  563.  
  564.  gad=InitGTGadget(gadgetID,helpID,LISTVIEW_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct ListviewData));
  565.  if(gad==NULL) { NoMemory(); return(FALSE); }
  566.  
  567.  ld=gad->ExtData;
  568.  NewList(&ld->List);
  569.  
  570.  if(labels)
  571.   {
  572.    i=0;
  573.    while(labels[i]!=NULL)
  574.     {
  575.      j=strlen(labels[i])+1;
  576.      ln=AllocMemory(&ld->Remember,sizeof(struct ListviewNode)+j,MEMF_PUBLIC);
  577.      if(ln==NULL) { NoMemory(); break; }
  578.      ln->Node.ln_Pred=NULL;
  579.      ln->Node.ln_Succ=NULL;
  580.      ln->Node.ln_Type=0;
  581.      ln->Node.ln_Pri=0;
  582.      ln->Node.ln_Name=&ln->Label;
  583.      CopyMem(labels[i],&ln->Label,j);
  584.      AddTail(&ld->List,ln);
  585.      i++;
  586.     }
  587.   }
  588.  
  589.  gad->TagList[LISTVIEW_LABELS].ti_Tag=GTLV_Labels;
  590.  gad->TagList[LISTVIEW_LABELS].ti_Data=&ld->List;
  591.  gad->TagList[LISTVIEW_TOP].ti_Tag=GTLV_Top;
  592.  gad->TagList[LISTVIEW_TOP].ti_Data=selected;
  593.  gad->TagList[LISTVIEW_SELECTED].ti_Tag=GTLV_Selected;
  594.  gad->TagList[LISTVIEW_SELECTED].ti_Data=selected;
  595.  gad->TagList[LISTVIEW_READONLY].ti_Tag=GTLV_ReadOnly;
  596.  gad->TagList[LISTVIEW_SHOWSELECTED].ti_Tag=TAG_IGNORE;
  597.  gad->TagList[LISTVIEW_RECESSED].ti_Tag=GTBB_Recessed;
  598.  
  599.  if(flags & CLV_READONLY)
  600.    gad->TagList[LISTVIEW_READONLY].ti_Data=TRUE;
  601.  
  602.  if(flags & CLV_SHOWSELECTED)
  603.    gad->TagList[LISTVIEW_SHOWSELECTED].ti_Tag=GTLV_ShowSelected;
  604.  
  605.  if(flags & CGA_RECESSED)
  606.    gad->TagList[LISTVIEW_RECESSED].ti_Data=TRUE;
  607.  
  608.  if(flags & CLV_NONPROPFONT)
  609.    gad->NewGadget.ng_TextAttr=mw->NonPropTextAttr;
  610.  
  611.  return(AddMWGadget(gad));
  612. }
  613.  
  614. /* ---- Listview-Gadget updaten */
  615. void UpdateListviewSelection(gadgetID,selected)
  616.  ULONG gadgetID;
  617.  LONG  selected;
  618. {
  619.  struct MWGadget     *gad;
  620.  struct WindowEntry  *we;
  621.  struct ListviewData *ld;
  622.  ULONG                i;
  623.  
  624.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  625.  if(gad)
  626.   {
  627.    we=gad->WindowEntry;
  628.  
  629.    ld=gad->ExtData;
  630.    i=CountNodes(&ld->List);
  631.    if(i==0) return;
  632.    if(selected>=i) selected=i-1;
  633.  
  634.    if(selected>=0)
  635.     {
  636.      gad->TagList[LISTVIEW_TOP].ti_Data=selected;
  637.      gad->TagList[LISTVIEW_SELECTED].ti_Data=selected;
  638.     }
  639.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  640.   }
  641. }
  642.  
  643. /* ---- Eintrag zum Listview-Gadget hinzufügen */
  644. void AddListviewEntrySort(gadgetID,label,place)
  645.  ULONG  gadgetID;
  646.  UBYTE *label;
  647.  UBYTE  place;
  648. {
  649.  BOOL                  okay;
  650.  struct TagItem        tag[2];
  651.  struct MWGadget      *gad;
  652.  struct WindowEntry   *we;
  653.  struct ListviewData  *ld;
  654.  struct ListviewNode  *ln;
  655.  int                   j;
  656.  
  657.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  658.  if(gad)
  659.   {
  660.    we=gad->WindowEntry;
  661.    ld=gad->ExtData;
  662.  
  663.    j=strlen(label)+1;
  664.    ln=AllocMemory(&ld->Remember,sizeof(struct ListviewNode)+j,MEMF_PUBLIC);
  665.    if(ln==NULL) { NoMemory(); return; }
  666.    ln->Node.ln_Pred=NULL;
  667.    ln->Node.ln_Succ=NULL;
  668.    ln->Node.ln_Type=0;
  669.    ln->Node.ln_Pri=0;
  670.    ln->Node.ln_Name=&ln->Label;
  671.    CopyMem(label,&ln->Label,j);
  672.  
  673.    switch(place)
  674.     {
  675.      case ULP_HEAD:
  676.        AddHead(&ld->List,ln);
  677.       break;
  678.      case ULP_TAIL:
  679.        AddTail(&ld->List,ln);
  680.       break;
  681.      case ULP_SORTA:
  682.        InsertSort(&ld->List,ln,SORT_ASCENDING);
  683.       break;
  684.      case ULP_SORTD:
  685.        InsertSort(&ld->List,ln,SORT_DESCENDING);
  686.       break;
  687.     }
  688.  
  689.    if(!we->Iconify)
  690.     {
  691.      tag[0].ti_Tag=GTLV_Labels;
  692.      tag[0].ti_Data=&ld->List;
  693.      tag[1].ti_Tag=TAG_DONE;
  694.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  695.     }
  696.   }
  697. }
  698.  
  699. /* ---- Eintrag zum Listview-Gadget hinzufügen */
  700. void AddListviewEntryNumber(gadgetID,label,num)
  701.  ULONG  gadgetID;
  702.  UBYTE *label;
  703.  ULONG   num;
  704. {
  705.  BOOL                  okay;
  706.  struct TagItem        tag[2];
  707.  struct MWGadget      *gad;
  708.  struct WindowEntry   *we;
  709.  struct ListviewData  *ld;
  710.  struct ListviewNode  *ln;
  711.  struct Node          *pred;
  712.  int                   j;
  713.  
  714.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  715.  if(gad)
  716.   {
  717.    we=gad->WindowEntry;
  718.    ld=gad->ExtData;
  719.  
  720.    j=strlen(label)+1;
  721.    ln=AllocMemory(&ld->Remember,sizeof(struct ListviewNode)+j,MEMF_PUBLIC);
  722.    if(ln==NULL) { NoMemory(); return; }
  723.    ln->Node.ln_Pred=NULL;
  724.    ln->Node.ln_Succ=NULL;
  725.    ln->Node.ln_Type=0;
  726.    ln->Node.ln_Pri=0;
  727.    ln->Node.ln_Name=&ln->Label;
  728.    CopyMem(label,&ln->Label,j);
  729.  
  730.    pred=FindNode(&ld->List,num);
  731.    if(pred==NULL)
  732.      AddTail(&ld->List,ln);
  733.    else
  734.      Insert(&ld->List,ln,pred);
  735.  
  736.    if(!we->Iconify)
  737.     {
  738.      tag[0].ti_Tag=GTLV_Labels;
  739.      tag[0].ti_Data=&ld->List;
  740.      tag[1].ti_Tag=TAG_DONE;
  741.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  742.     }
  743.   }
  744. }
  745.  
  746. /* ---- Eintrag im Listview-Gadget entfernen */
  747. void RemListviewEntryLabel(gadgetID,label)
  748.  ULONG  gadgetID;
  749.  UBYTE *label;
  750. {
  751.  struct TagItem       tag[3];
  752.  struct MWGadget     *gad;
  753.  struct WindowEntry  *we;
  754.  struct ListviewData *ld;
  755.  struct ListviewNode *ln;
  756.  
  757.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  758.  if(gad)
  759.   {
  760.    we=gad->WindowEntry;
  761.  
  762.    ld=gad->ExtData;
  763.    ln=FindName(&ld->List,label);
  764.    if(ln==NULL) return;
  765.  
  766.    Remove(ln);
  767.    FreeMemoryBlock(&ld->Remember,ln);
  768.    gad->TagList[LISTVIEW_SELECTED].ti_Data=-1L;
  769.  
  770.    if(!we->Iconify)
  771.     {
  772.      tag[0].ti_Tag=GTLV_Labels;
  773.      tag[0].ti_Data=&ld->List;
  774.      tag[1].ti_Tag=GTLV_Selected;
  775.      tag[1].ti_Data=-1L;
  776.      tag[2].ti_Tag=TAG_DONE;
  777.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  778.     }
  779.    CallAction(gad);
  780.   }
  781. }
  782.  
  783. /* ---- Eintrag im Listview-Gadget entfernen */
  784. void RemListviewEntryNumber(gadgetID,num)
  785.  ULONG gadgetID;
  786.  LONG  num;
  787. {
  788.  struct TagItem         tag[3];
  789.  struct MWGadget       *gad;
  790.  struct WindowEntry    *we;
  791.  struct ListviewData   *ld;
  792.  struct ListviewNode   *found;
  793.  struct Node  *ln;
  794.  long          i;
  795.  
  796.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  797.  if(gad)
  798.   {
  799.    we=gad->WindowEntry;
  800.    ld=gad->ExtData;
  801.  
  802.    if(num>0)
  803.     {
  804.      i=0;
  805.      found=NULL;
  806.      for(ln=ld->List.lh_Head;ln!=&ld->List.lh_Tail;ln=ln->ln_Succ)
  807.       {
  808.        if(i==num) { found=ln; break; }
  809.        i++;
  810.       }
  811.      if(found) Remove(found);
  812.     }
  813.    else if(num=0)
  814.      found=RemHead(&ld->List);
  815.    else
  816.      found=RemTail(&ld->List);
  817.  
  818.    if(found==NULL) return;
  819.    Remove(found);
  820.    FreeMemoryBlock(&ld->Remember,found);
  821.    gad->TagList[LISTVIEW_SELECTED].ti_Data=-1L;
  822.  
  823.    if(!we->Iconify)
  824.     {
  825.      tag[0].ti_Tag=GTLV_Labels;
  826.      tag[0].ti_Data=&ld->List;
  827.      tag[1].ti_Tag=GTLV_Selected;
  828.      tag[1].ti_Data=-1L;
  829.      tag[2].ti_Tag=TAG_DONE;
  830.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  831.     }
  832.    CallAction(gad);
  833.   }
  834. }
  835.  
  836. /* ---- Alle Einträge im Listview-Gadget entfernen */
  837. void RemListviewEntries(gadgetID)
  838.  ULONG gadgetID;
  839. {
  840.  struct TagItem         tag[3];
  841.  struct MWGadget       *gad;
  842.  struct WindowEntry    *we;
  843.  struct ListviewData   *ld;
  844.  
  845.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  846.  if(gad)
  847.   {
  848.    we=gad->WindowEntry;
  849.    ld=gad->ExtData;
  850.  
  851.    FreeMemory(&ld->Remember);
  852.    NewList(&ld->List);
  853.    gad->TagList[LISTVIEW_SELECTED].ti_Data=-1L;
  854.  
  855.    if(!we->Iconify)
  856.     {
  857.      tag[0].ti_Tag=GTLV_Labels;
  858.      tag[0].ti_Data=&ld->List;
  859.      tag[1].ti_Tag=GTLV_Selected;
  860.      tag[1].ti_Data=-1L;
  861.      tag[2].ti_Tag=TAG_DONE;
  862.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  863.     }
  864.    CallAction(gad);
  865.   }
  866. }
  867.  
  868. /* ---- Alle Einträge im Listview-Gadget sortieren */
  869. void SortListviewEntries(gadgetID,place)
  870.  ULONG gadgetID;
  871.  UBYTE place;
  872. {
  873.  struct TagItem         tag[3];
  874.  struct MWGadget       *gad;
  875.  struct WindowEntry    *we;
  876.  struct ListviewData   *ld;
  877.  
  878.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  879.  if(gad)
  880.   {
  881.    we=gad->WindowEntry;
  882.    ld=gad->ExtData;
  883.  
  884.    SortList(&ld->List,place);
  885.    if(!we->Iconify)
  886.     {
  887.      tag[0].ti_Tag=GTLV_Labels;
  888.      tag[0].ti_Data=&ld->List;
  889.      tag[1].ti_Tag=GTLV_Selected;
  890.      tag[1].ti_Data=-1L;
  891.      tag[2].ti_Tag=TAG_DONE;
  892.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  893.     }
  894.    CallAction(gad);
  895.   }
  896. }
  897.  
  898. /* ---- Auswahl des Listview-Gadget ermitteln */
  899. LONG AskListviewSelection(gadgetID)
  900.  ULONG gadgetID;
  901. {
  902.  struct MWGadget *gad;
  903.  
  904.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  905.  if(gad)
  906.    return(gad->TagList[LISTVIEW_SELECTED].ti_Data);
  907.  return(-1L);
  908. }
  909.  
  910. /* ---- Auswahl des Listview-Gadget ermitteln */
  911. UBYTE *AskListviewSelectionLabel(gadgetID)
  912.  ULONG gadgetID;
  913. {
  914.  struct MWGadget     *gad;
  915.  struct ListviewData *ld;
  916.  struct Node         *node;
  917.  
  918.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  919.  if(gad)
  920.   {
  921.    ld=gad->ExtData;
  922.    node=FindNode(&ld->List,gad->TagList[LISTVIEW_SELECTED].ti_Data);
  923.    if(node==NULL) return(NULL);
  924.    return(node->ln_Name);
  925.   }
  926.  return(NULL);
  927. }
  928.  
  929. /* ---- MX-Gadget erstellen */
  930. BOOL AddMX(gadgetID,helpID,x,y,w,h,pad,flags,labels,active)
  931.  ULONG          gadgetID;
  932.  ULONG          helpID;
  933.  UWORD          x,y,w,h;
  934.  ULONG          pad;
  935.  UWORD          flags;
  936.  ULONG         *labels;
  937.  UBYTE          active;
  938. {
  939.  UBYTE                   *title;
  940.  struct MWGadget         *gad;
  941.  struct WindowEntry      *we;
  942.  struct MultiWindowsUser *mw;
  943.  struct MXData           *md;
  944.  struct Gadget           *g;
  945.  int                      i,j,k;
  946.  
  947.  USER;
  948.  WE;
  949.  if(we==NULL) return(FALSE);
  950.  
  951.  gad=InitGTGadget(gadgetID,helpID,MX_KIND,x,y,w,h,0,PlaceText(flags,PLACETEXT_RIGHT),sizeof(struct MXData));
  952.  if(gad==NULL) { NoMemory(); return(FALSE); }
  953.  
  954.  md=gad->ExtData;
  955.  for(i=0;i<12;i++)
  956.   {
  957.    if(labels[i]==0) break;
  958.    md->Labels[i]=FindID(mw->Catalog,labels[i]);
  959.    md->LabelCount++;
  960.  
  961.    title=md->Labels[i];
  962.    if(title)
  963.     {
  964.      j=strlen(title);
  965.      for(k=0;k<j;k++)
  966.       {
  967.        if(title[k]=='_')
  968.         {
  969.          md->CommandKey[i]=toupper(title[k+1]); break;
  970.         }
  971.       }
  972.     }
  973.   }
  974.  md->Labels[12]=0L;
  975.  
  976.  gad->TagList[GADGET_DISABLE].ti_Tag=TAG_IGNORE;
  977.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  978.  
  979.  gad->TagList[MX_LABELS].ti_Tag=GTMX_Labels;
  980.  gad->TagList[MX_LABELS].ti_Data=&md->Labels;
  981.  gad->TagList[MX_ACTIVE].ti_Tag=GTMX_Active;
  982.  gad->TagList[MX_ACTIVE].ti_Data=active;
  983.  
  984.  return(AddMWGadget(gad));
  985. }
  986.  
  987. /* ---- MX-Gadget updaten */
  988. void UpdateMX(gadgetID,active)
  989.  ULONG gadgetID;
  990.  UBYTE active;
  991. {
  992.  struct MWGadget    *gad;
  993.  struct WindowEntry *we;
  994.  struct MXData      *mx;
  995.  
  996.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,MX_KIND);
  997.  if(gad)
  998.   {
  999.    we=gad->WindowEntry;
  1000.    mx=gad->ExtData;
  1001.    if(mx->LabelCount==0) return;
  1002.    if(active>=mx->LabelCount) active=mx->LabelCount-1;
  1003.    gad->TagList[MX_ACTIVE].ti_Data=active;
  1004.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1005.   }
  1006. }
  1007.  
  1008. /* ---- Auswahl des MX-Gadget ermitteln */
  1009. LONG AskMX(gadgetID)
  1010.  ULONG gadgetID;
  1011. {
  1012.  struct MWGadget *gad;
  1013.  
  1014.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,MX_KIND);
  1015.  if(gad)
  1016.    return(gad->TagList[MX_ACTIVE].ti_Data);
  1017.  return(-1L);
  1018. }
  1019.  
  1020. /* ---- String-Gadget erstellen */
  1021. BOOL AddString(gadgetID,helpID,x,y,w,h,textID,flags,string,max)
  1022.  ULONG          gadgetID;
  1023.  ULONG          helpID;
  1024.  UWORD          x,y,w,h;
  1025.  ULONG          textID;
  1026.  UWORD          flags;
  1027.  UBYTE         *string;
  1028.  LONG           max;
  1029. {
  1030.  struct MWGadget         *gad;
  1031.  struct WindowEntry      *we;
  1032.  struct StringData       *sd;
  1033.  struct Gadget           *g;
  1034.  long                     j;
  1035.  
  1036.  WE;
  1037.  if(we==NULL) return(FALSE);
  1038.  
  1039.  gad=InitGTGadget(gadgetID,helpID,STRING_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct StringData)+max+2);
  1040.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1041.  
  1042.  sd=gad->ExtData;
  1043.  sd->Buffer=(ULONG)gad->ExtData+(ULONG)sizeof(struct StringData);
  1044.  
  1045.  if(string==NULL) string="";
  1046.  strcpy(sd->Buffer,string);
  1047.  
  1048.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1049.  gad->TagList[STRING_MAXCHARS].ti_Tag=GTST_MaxChars;
  1050.  gad->TagList[STRING_MAXCHARS].ti_Data=max;
  1051.  gad->TagList[STRING_STRING].ti_Tag=GTST_String;
  1052.  gad->TagList[STRING_STRING].ti_Data=sd->Buffer;
  1053.  gad->TagList[STRING_JUSTIFICATION].ti_Tag=STRINGA_Justification;
  1054.  
  1055.  if(flags & CST_CENTER)
  1056.   j=GACT_STRINGCENTER;
  1057.  else if(flags &CST_LEFT)
  1058.   j=GACT_STRINGLEFT;
  1059.  else
  1060.   j=GACT_STRINGRIGHT;
  1061.  gad->TagList[STRING_JUSTIFICATION].ti_Data=j;
  1062.  
  1063.  if(flags & CST_PASSWORD) {
  1064.    if(gad->NewGadget.ng_Height>14)
  1065.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password9Attr;
  1066.    else
  1067.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password5Attr;
  1068.   }
  1069.  
  1070.  return(AddMWGadget(gad));
  1071. }
  1072. /* ---- String-Gadget mit Hook erstellen */
  1073. BOOL AddHookString(gadgetID,helpID,x,y,w,h,textID,flags,string,max,sh)
  1074.  ULONG              gadgetID;
  1075.  ULONG              helpID;
  1076.  UWORD              x,y,w,h;
  1077.  ULONG              textID;
  1078.  UWORD              flags;
  1079.  UBYTE             *string;
  1080.  LONG               max;
  1081.  struct StringHook *sh;
  1082. {
  1083.  struct MWGadget         *gad;
  1084.  struct WindowEntry      *we;
  1085.  struct StringData       *sd;
  1086.  struct Gadget           *g;
  1087.  long                     j;
  1088.  
  1089.  WE;
  1090.  if(we==NULL) return(FALSE);
  1091.  
  1092.  gad=InitGTGadget(gadgetID,helpID,STRING_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct StringData)+(max*2)+4);
  1093.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1094.  
  1095.  sd=gad->ExtData;
  1096.  sd->Hook=&MultiWindowsBase->UserHook;
  1097.  sd->Buffer=(ULONG)gad->ExtData+(ULONG)sizeof(struct StringData);
  1098.  sd->WorkBuffer=(ULONG)sd->Buffer+(ULONG)max+2L;
  1099.  sd->SpecialType=SST_USER;
  1100.  sd->Special=sh;
  1101.  
  1102.  if(string==NULL) string="";
  1103.  strcpy(sd->Buffer,string);
  1104.  
  1105.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1106.  gad->TagList[STRING_MAXCHARS].ti_Tag=GTST_MaxChars;
  1107.  gad->TagList[STRING_MAXCHARS].ti_Data=max;
  1108.  gad->TagList[STRING_STRING].ti_Tag=GTST_String;
  1109.  gad->TagList[STRING_STRING].ti_Data=sd->Buffer;
  1110.  gad->TagList[STRING_JUSTIFICATION].ti_Tag=STRINGA_Justification;
  1111.  
  1112.  if(flags & CST_CENTER)
  1113.   j=GACT_STRINGCENTER;
  1114.  else if(flags &CST_LEFT)
  1115.   j=GACT_STRINGLEFT;
  1116.  else
  1117.   j=GACT_STRINGRIGHT;
  1118.  gad->TagList[STRING_JUSTIFICATION].ti_Data=j;
  1119.  
  1120.  if(flags & CST_PASSWORD) {
  1121.    if(gad->NewGadget.ng_Height>14)
  1122.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password9Attr;
  1123.    else
  1124.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password5Attr;
  1125.   }
  1126.  
  1127.  return(AddMWGadget(gad));
  1128. }
  1129.  
  1130. /* ---- Text des String-Gadget ermitteln */
  1131. UBYTE *AskString(gadgetID)
  1132.  ULONG gadgetID;
  1133. {
  1134.  struct MWGadget   *gad;
  1135.  struct StringData *sd;
  1136.  
  1137.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1138.  if(gad)
  1139.   {
  1140.    sd=gad->ExtData;
  1141.    if((sd->SpecialType!=SST_STRING)&&(sd->SpecialType==SST_USER)) return(NULL);
  1142.  
  1143.    return(sd->Buffer);
  1144.   }
  1145.  return(NULL);
  1146. }
  1147.  
  1148. /* ---- Text des String-Gadget updaten */
  1149. void UpdateString(gadgetID,string)
  1150.  ULONG  gadgetID;
  1151.  UBYTE *string;
  1152. {
  1153.  UBYTE              *mem;
  1154.  struct MWGadget    *gad;
  1155.  struct WindowEntry *we;
  1156.  struct StringData  *sd;
  1157.  long                i,j;
  1158.  
  1159.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1160.  if(gad)
  1161.   {
  1162.    we=gad->WindowEntry;
  1163.  
  1164.    sd=gad->ExtData;
  1165.    if((sd->SpecialType!=SST_STRING)&&(sd->SpecialType!=SST_USER)) return;
  1166.  
  1167.    mem=sd->Buffer;
  1168.    if(string!=NULL)
  1169.     {
  1170.      i=strlen(string)+1;
  1171.      j=gad->TagList[STRING_MAXCHARS].ti_Data;
  1172.      if(i>j) i=j;
  1173.      CopyMem(string,mem,i);
  1174.      mem[i]=0x00;
  1175.     }
  1176.    else
  1177.      mem[0]=0x00;
  1178.  
  1179.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1180.   }
  1181. }
  1182.  
  1183. /* ---- Integer-Gadget erstellen */
  1184. BOOL AddInteger(gadgetID,helpID,x,y,w,h,textID,flags,integer,min,max)
  1185.  ULONG          gadgetID;
  1186.  ULONG          helpID;
  1187.  UWORD          x,y,w,h;
  1188.  ULONG          textID;
  1189.  UWORD          flags;
  1190.  LONG           integer;
  1191.  LONG           min;
  1192.  LONG           max;
  1193. {
  1194.  struct MWGadget         *gad;
  1195.  struct WindowEntry      *we;
  1196.  struct Gadget           *g;
  1197.  struct IntegerData      *id;
  1198.  long                     j;
  1199.  
  1200.  WE;
  1201.  if(we==NULL) return(FALSE);
  1202.  
  1203.  gad=InitGTGadget(gadgetID,helpID,INTEGER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct IntegerData));
  1204.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1205.  id=gad->ExtData;
  1206.  
  1207.  id->Min=min;
  1208.  id->Max=max;
  1209.  if(integer<id->Min) integer=id->Min;
  1210.  if(integer>id->Max) integer=id->Max;
  1211.  
  1212.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1213.  gad->TagList[INTEGER_MAXCHARS].ti_Tag=GTIN_MaxChars;
  1214.  gad->TagList[INTEGER_MAXCHARS].ti_Data=14;
  1215.  gad->TagList[INTEGER_INTEGER].ti_Tag=GTIN_Number;
  1216.  gad->TagList[INTEGER_INTEGER].ti_Data=integer;
  1217.  gad->TagList[INTEGER_JUSTIFICATION].ti_Tag=STRINGA_Justification;
  1218.  
  1219.  if(flags & CIN_CENTER)
  1220.    j=GACT_STRINGCENTER;
  1221.  else if(flags & CIN_LEFT)
  1222.    j=GACT_STRINGLEFT;
  1223.  else
  1224.    j=GACT_STRINGRIGHT;
  1225.  gad->TagList[STRING_JUSTIFICATION].ti_Data=j;
  1226.  
  1227.  if(flags & CIN_PASSWORD) {
  1228.   if(gad->NewGadget.ng_Height>14)
  1229.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password9Attr;
  1230.    else
  1231.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password5Attr;
  1232.   }
  1233.  
  1234.  return(AddMWGadget(gad));
  1235. }
  1236.  
  1237. /* ---- Nummer im Integer-Gadget ermitteln */
  1238. LONG AskInteger(gadgetID)
  1239.  ULONG gadgetID;
  1240. {
  1241.  struct MWGadget   *gad;
  1242.  struct StringInfo *si;
  1243.  
  1244.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,INTEGER_KIND);
  1245.  if(gad)
  1246.   {
  1247.    si=gad->Update->SpecialInfo;
  1248.    return(atol(si->Buffer));
  1249.   }
  1250.  return(NULL);
  1251. }
  1252.  
  1253. /* ---- Nummer im Integer-Gadget updaten */
  1254. void UpdateInteger(gadgetID,integer)
  1255.  ULONG  gadgetID;
  1256.  LONG   integer;
  1257. {
  1258.  UBYTE              *mem;
  1259.  struct MWGadget    *gad;
  1260.  struct WindowEntry *we;
  1261.  struct IntegerData *id;
  1262.  
  1263.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,INTEGER_KIND);
  1264.  if(gad)
  1265.   {
  1266.    we=gad->WindowEntry;
  1267.    id=gad->ExtData;
  1268.  
  1269.    if(integer<id->Min) integer=id->Min;
  1270.    if(integer>id->Max) integer=id->Max;
  1271.  
  1272.    gad->TagList[INTEGER_INTEGER].ti_Data=integer;
  1273.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1274.   }
  1275. }
  1276.  
  1277. /* ---- Horizontales Slider-Gadget erstellen */
  1278. BOOL AddHSlider(gadgetID,helpID,x,y,w,h,textID,flags,level,min,max)
  1279.  ULONG          gadgetID;
  1280.  ULONG          helpID;
  1281.  UWORD          x,y,w,h;
  1282.  ULONG          textID;
  1283.  UWORD          flags;
  1284.  LONG           level,min,max;
  1285. {
  1286.  struct MWGadget         *gad;
  1287.  struct WindowEntry      *we;
  1288.  struct MultiWindowsUser *mw;
  1289.  
  1290.  USER;
  1291.  WE;
  1292.  if(we==NULL) return(FALSE);
  1293.  
  1294.  gad=InitGTGadget(gadgetID,helpID,SLIDER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),0L);
  1295.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1296.  
  1297.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1298.  gad->TagList[SLIDER_MIN].ti_Tag=GTSL_Min;
  1299.  gad->TagList[SLIDER_MIN].ti_Data=min;
  1300.  gad->TagList[SLIDER_MAX].ti_Tag=GTSL_Max;
  1301.  gad->TagList[SLIDER_MAX].ti_Data=max;
  1302.  gad->TagList[SLIDER_LEVEL].ti_Tag=GTSL_Level;
  1303.  gad->TagList[SLIDER_LEVEL].ti_Data=level;
  1304.  gad->TagList[SLIDER_RELVERIFY].ti_Tag=GA_RelVerify;
  1305.  gad->TagList[SLIDER_RELVERIFY].ti_Data=TRUE;
  1306.  gad->TagList[SLIDER_IMMEDIATE].ti_Tag=GA_Immediate;
  1307.  gad->TagList[SLIDER_IMMEDIATE].ti_Data=TRUE;
  1308.  gad->TagList[SLIDER_FREEDOM].ti_Tag=PGA_Freedom;
  1309.  gad->TagList[SLIDER_FREEDOM].ti_Data=LORIENT_HORIZ;
  1310.  gad->TagList[SLIDER_FOLLOWMOUSE].ti_Tag=GA_FollowMouse;
  1311.  gad->TagList[SLIDER_FOLLOWMOUSE].ti_Data=TRUE;
  1312.  return(AddMWGadget(gad));
  1313. }
  1314.  
  1315. /* ---- Vertikales Slider-Gadget erstellen */
  1316. BOOL AddVSlider(gadgetID,helpID,x,y,w,h,textID,flags,level,min,max)
  1317.  ULONG          gadgetID;
  1318.  ULONG          helpID;
  1319.  UWORD          x,y,w,h;
  1320.  ULONG          textID;
  1321.  UWORD          flags;
  1322.  LONG           level,min,max;
  1323. {
  1324.  struct MWGadget         *gad;
  1325.  struct WindowEntry      *we;
  1326.  struct MultiWindowsUser *mw;
  1327.  
  1328.  USER;
  1329.  WE;
  1330.  if(we==NULL) return(FALSE);
  1331.  
  1332.  gad=InitGTGadget(gadgetID,helpID,SLIDER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),0L);
  1333.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1334.  
  1335.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1336.  gad->TagList[SLIDER_MIN].ti_Tag=GTSL_Min;
  1337.  gad->TagList[SLIDER_MIN].ti_Data=min;
  1338.  gad->TagList[SLIDER_MAX].ti_Tag=GTSL_Max;
  1339.  gad->TagList[SLIDER_MAX].ti_Data=max;
  1340.  gad->TagList[SLIDER_LEVEL].ti_Tag=GTSL_Level;
  1341.  gad->TagList[SLIDER_LEVEL].ti_Data=level;
  1342.  gad->TagList[SLIDER_RELVERIFY].ti_Tag=GA_RelVerify;
  1343.  gad->TagList[SLIDER_RELVERIFY].ti_Data=TRUE;
  1344.  gad->TagList[SLIDER_FREEDOM].ti_Tag=PGA_Freedom;
  1345.  gad->TagList[SLIDER_FREEDOM].ti_Data=LORIENT_VERT;
  1346.  gad->TagList[SLIDER_FOLLOWMOUSE].ti_Tag=GA_FollowMouse;
  1347.  gad->TagList[SLIDER_FOLLOWMOUSE].ti_Data=TRUE;
  1348.  
  1349.  return(AddMWGadget(gad));
  1350. }
  1351.  
  1352. /* ---- Slider abfragen */
  1353. LONG AskSlider(gadgetID)
  1354.  ULONG gadgetID;
  1355. {
  1356.  struct MWGadget    *gad;
  1357.  
  1358.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,SLIDER_KIND);
  1359.  if(gad)
  1360.    return((WORD)gad->TagList[SLIDER_LEVEL].ti_Data);
  1361.  return(-1);
  1362. }
  1363.  
  1364. /* ---- Slider updaten */
  1365. void UpdateSlider(gadgetID,level)
  1366.  ULONG gadgetID;
  1367.  LONG  level;
  1368. {
  1369.  struct MWGadget    *gad;
  1370.  struct WindowEntry *we;
  1371.  
  1372.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,SLIDER_KIND);
  1373.  if(gad)
  1374.   {
  1375.    we=gad->WindowEntry;
  1376.    if(level!=-1L) gad->TagList[SLIDER_LEVEL].ti_Data=level;
  1377.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1378.   }
  1379. }
  1380.  
  1381. /* ---- Slider updaten */
  1382. void UpdateSliderLimits(gadgetID,min,max)
  1383.  ULONG gadgetID;
  1384.  LONG  min,max;
  1385. {
  1386.  struct MWGadget    *gad;
  1387.  struct WindowEntry *we;
  1388.  
  1389.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,SLIDER_KIND);
  1390.  if(gad)
  1391.   {
  1392.    we=gad->WindowEntry;
  1393.    if(min!=-1L) gad->TagList[SLIDER_MIN].ti_Data=min;
  1394.    if(max!=-1L) gad->TagList[SLIDER_MAX].ti_Data=max;
  1395.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1396.   }
  1397. }
  1398.  
  1399. /* ---- Horizontales Scroller-Gadget erstellen */
  1400. BOOL AddHScroller(gadgetID,helpID,x,y,w,h,textID,flags,top,visible,total)
  1401.  ULONG          gadgetID;
  1402.  ULONG          helpID;
  1403.  UWORD          x,y,w,h;
  1404.  ULONG          textID;
  1405.  UWORD          flags;
  1406.  LONG           top,visible,total;
  1407. {
  1408.  struct MWGadget         *gad;
  1409.  struct WindowEntry      *we;
  1410.  struct MultiWindowsUser *mw;
  1411.  int                      arrows;
  1412.  
  1413.  USER;
  1414.  WE;
  1415.  if(we==NULL) return(FALSE);
  1416.  
  1417.  gad=InitGTGadget(gadgetID,helpID,SCROLLER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1418.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1419.  
  1420.  if(flags & CSC_ARROWS)
  1421.   {  if(w<50) arrows=0; else arrows=15; }
  1422.  else
  1423.   arrows=0;
  1424.  
  1425.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1426.  gad->TagList[SCROLLER_TOP].ti_Tag=GTSC_Top;
  1427.  gad->TagList[SCROLLER_TOP].ti_Data=top;
  1428.  gad->TagList[SCROLLER_TOTAL].ti_Tag=GTSC_Total;
  1429.  gad->TagList[SCROLLER_TOTAL].ti_Data=total;
  1430.  gad->TagList[SCROLLER_VISIBLE].ti_Tag=GTSC_Visible;
  1431.  gad->TagList[SCROLLER_VISIBLE].ti_Data=visible;
  1432.  gad->TagList[SCROLLER_ARROWS].ti_Tag=GTSC_Arrows;
  1433.  gad->TagList[SCROLLER_ARROWS].ti_Data=arrows;
  1434.  gad->TagList[SCROLLER_RELVERIFY].ti_Tag=GA_RelVerify;
  1435.  gad->TagList[SCROLLER_RELVERIFY].ti_Data=TRUE;
  1436.  gad->TagList[SCROLLER_IMMEDIATE].ti_Tag=GA_Immediate;
  1437.  gad->TagList[SCROLLER_IMMEDIATE].ti_Data=TRUE;
  1438.  gad->TagList[SCROLLER_FREEDOM].ti_Tag=PGA_Freedom;
  1439.  gad->TagList[SCROLLER_FREEDOM].ti_Data=LORIENT_HORIZ;
  1440.  
  1441.  return(AddMWGadget(gad));
  1442. }
  1443.  
  1444. /* ---- Vertikales Scroller-Gadget erstellen */
  1445. BOOL AddVScroller(gadgetID,helpID,x,y,w,h,textID,flags,top,visible,total)
  1446.  ULONG          gadgetID;
  1447.  ULONG          helpID;
  1448.  UWORD          x,y,w,h;
  1449.  ULONG          textID;
  1450.  UWORD          flags;
  1451.  LONG           top,visible,total;
  1452. {
  1453.  struct MWGadget         *gad;
  1454.  struct WindowEntry      *we;
  1455.  struct MultiWindowsUser *mw;
  1456.  int                      arrows;
  1457.  
  1458.  USER;
  1459.  WE;
  1460.  if(we==NULL) return(FALSE);
  1461.  
  1462.  gad=InitGTGadget(gadgetID,helpID,SCROLLER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1463.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1464.  
  1465.  if(flags & CSC_ARROWS)
  1466.   {  if(h<40) arrows=0; else arrows=15; }
  1467.  else
  1468.   arrows=0;
  1469.  
  1470.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1471.  gad->TagList[SCROLLER_TOP].ti_Tag=GTSC_Top;
  1472.  gad->TagList[SCROLLER_TOP].ti_Data=top;
  1473.  gad->TagList[SCROLLER_TOTAL].ti_Tag=GTSC_Total;
  1474.  gad->TagList[SCROLLER_TOTAL].ti_Data=total;
  1475.  gad->TagList[SCROLLER_VISIBLE].ti_Tag=GTSC_Visible;
  1476.  gad->TagList[SCROLLER_VISIBLE].ti_Data=visible;
  1477.  gad->TagList[SCROLLER_ARROWS].ti_Tag=GTSC_Arrows;
  1478.  gad->TagList[SCROLLER_ARROWS].ti_Data=arrows;
  1479.  gad->TagList[SCROLLER_RELVERIFY].ti_Tag=GA_RelVerify;
  1480.  gad->TagList[SCROLLER_RELVERIFY].ti_Data=TRUE;
  1481.  gad->TagList[SCROLLER_IMMEDIATE].ti_Tag=GA_Immediate;
  1482.  gad->TagList[SCROLLER_IMMEDIATE].ti_Data=TRUE;
  1483.  gad->TagList[SCROLLER_FREEDOM].ti_Tag=PGA_Freedom;
  1484.  gad->TagList[SCROLLER_FREEDOM].ti_Data=LORIENT_VERT;
  1485.  
  1486.  return(AddMWGadget(gad));
  1487. }
  1488.  
  1489. /* ---- Scroller abfragen */
  1490. LONG AskScroller(gadgetID)
  1491.  ULONG gadgetID;
  1492. {
  1493.  struct MWGadget    *gad;
  1494.  
  1495.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,SCROLLER_KIND);
  1496.  if(gad)
  1497.    return((WORD)gad->TagList[SCROLLER_TOP].ti_Data);
  1498.  return(-1);
  1499. }
  1500.  
  1501. /* ---- Scroller updaten */
  1502. void UpdateScroller(gadgetID,top,visible,total)
  1503.  ULONG gadgetID;
  1504.  LONG  top,visible,total;
  1505. {
  1506.  struct MWGadget    *gad;
  1507.  struct WindowEntry *we;
  1508.  
  1509.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,SCROLLER_KIND);
  1510.  if(gad)
  1511.   {
  1512.    we=gad->WindowEntry;
  1513.    if(top!=-1L) gad->TagList[SCROLLER_TOP].ti_Data=top;
  1514.    if(total!=-1L) gad->TagList[SCROLLER_TOTAL].ti_Data=total;
  1515.    if(visible!=-1L) gad->TagList[SCROLLER_VISIBLE].ti_Data=visible;
  1516.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1517.   }
  1518. }
  1519.  
  1520. /* ---- Palette hinzufügen */
  1521. BOOL AddPalette(gadgetID,helpID,x,y,w,h,textID,flags,depth,cOffset,color)
  1522.  ULONG          gadgetID;
  1523.  ULONG          helpID;
  1524.  UWORD          x,y,w,h;
  1525.  ULONG          textID;
  1526.  UWORD           flags;
  1527.  UBYTE           depth,cOffset,color;
  1528. {
  1529.  struct MWGadget         *gad;
  1530.  struct WindowEntry      *we;
  1531.  struct MultiWindowsUser *mw;
  1532.  struct CycleData        *cd;
  1533.  int                      i;
  1534.  
  1535.  USER;
  1536.  WE;
  1537.  if(we==NULL) return(FALSE);
  1538.  
  1539.  gad=InitGTGadget(gadgetID,helpID,PALETTE_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1540.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1541.  
  1542.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1543.  gad->TagList[PALETTE_DEPTH].ti_Tag=GTPA_Depth;
  1544.  gad->TagList[PALETTE_DEPTH].ti_Data=depth;
  1545.  gad->TagList[PALETTE_OFFSET].ti_Tag=GTPA_ColorOffset;
  1546.  gad->TagList[PALETTE_OFFSET].ti_Data=cOffset;
  1547.  gad->TagList[PALETTE_COLOR].ti_Tag=GTPA_Color;
  1548.  gad->TagList[PALETTE_COLOR].ti_Data=color;
  1549.  gad->TagList[PALETTE_IWIDTH].ti_Tag=GTPA_IndicatorWidth;
  1550.  if(flags & CPL_IBOX) gad->TagList[PALETTE_IWIDTH].ti_Data=40;
  1551.  
  1552.  return(AddMWGadget(gad));
  1553. }
  1554.  
  1555. /* ---- Palette abfragen */
  1556. UBYTE AskPalette(gadgetID)
  1557.  ULONG gadgetID;
  1558. {
  1559.  struct MWGadget    *gad;
  1560.  
  1561.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,PALETTE_KIND);
  1562.  if(gad)
  1563.    return((WORD)gad->TagList[PALETTE_COLOR].ti_Data);
  1564.  return(-1);
  1565. }
  1566.  
  1567. /* ---- Palette updaten */
  1568. void UpdatePalette(gadgetID,color)
  1569.  ULONG gadgetID;
  1570.  UWORD color;
  1571. {
  1572.  struct MWGadget    *gad;
  1573.  struct WindowEntry *we;
  1574.  
  1575.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,PALETTE_KIND);
  1576.  if(gad)
  1577.   {
  1578.    we=gad->WindowEntry;
  1579.    if(color<(2^(gad->TagList[PALETTE_DEPTH].ti_Data)))
  1580.      gad->TagList[PALETTE_COLOR].ti_Data=color;
  1581.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1582.   }
  1583. }
  1584.  
  1585. /* ---- Checkbox hinzufügen */
  1586. BOOL AddCheckbox(gadgetID,helpID,x,y,w,h,textID,flags,checked)
  1587.  ULONG          gadgetID;
  1588.  ULONG          helpID;
  1589.  UWORD          x,y,w,h;
  1590.  ULONG          textID;
  1591.  UWORD          flags;
  1592.  BOOL           checked;
  1593. {
  1594.  struct MWGadget         *gad;
  1595.  struct WindowEntry      *we;
  1596.  struct MultiWindowsUser *mw;
  1597.  struct CycleData        *cd;
  1598.  int                      i;
  1599.  
  1600.  USER;
  1601.  WE;
  1602.  if(we==NULL) return(FALSE);
  1603.  
  1604.  gad=InitGTGadget(gadgetID,helpID,CHECKBOX_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1605.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1606.  
  1607.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1608.  gad->TagList[CHECKBOX_CHECKED].ti_Tag=GTCB_Checked;
  1609.  gad->TagList[CHECKBOX_CHECKED].ti_Data=checked;
  1610.  
  1611.  return(AddMWGadget(gad));
  1612. }
  1613.  
  1614. /* ---- Checkbox abfragen */
  1615. BOOL AskCheckbox(gadgetID)
  1616.  ULONG gadgetID;
  1617. {
  1618.  struct MWGadget    *gad;
  1619.  
  1620.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,CHECKBOX_KIND);
  1621.  if(gad)
  1622.    return((WORD)gad->TagList[CHECKBOX_CHECKED].ti_Data);
  1623.  return(-1);
  1624. }
  1625.  
  1626. /* ---- Checkbox updaten */
  1627. void UpdateCheckbox(gadgetID,checked)
  1628.  ULONG gadgetID;
  1629.  BOOL  checked;
  1630. {
  1631.  struct MWGadget    *gad;
  1632.  struct WindowEntry *we;
  1633.  
  1634.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,CHECKBOX_KIND);
  1635.  if(gad)
  1636.   {
  1637.    we=gad->WindowEntry;
  1638.    gad->TagList[CHECKBOX_CHECKED].ti_Data=checked;
  1639.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1640.   }
  1641. }
  1642.  
  1643. /* ---- Text-Anzeige hinzufügen */
  1644. BOOL AddTX(gadgetID,helpID,x,y,w,h,textID,flags,text)
  1645.  ULONG          gadgetID;
  1646.  ULONG          helpID;
  1647.  UWORD          x,y,w,h;
  1648.  ULONG          textID;
  1649.  UWORD          flags;
  1650.  UBYTE         *text;
  1651. {
  1652.  struct MWGadget         *gad;
  1653.  struct WindowEntry      *we;
  1654.  struct MultiWindowsUser *mw;
  1655.  struct CycleData        *cd;
  1656.  int                      i;
  1657.  
  1658.  USER;
  1659.  WE;
  1660.  if(we==NULL) return(FALSE);
  1661.  
  1662.  gad=InitGTGadget(gadgetID,helpID,TEXT_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1663.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1664.  
  1665.  gad->TagList[TEXT_TEXT].ti_Tag=GTTX_Text;
  1666.  gad->TagList[TEXT_TEXT].ti_Data=text;
  1667.  gad->TagList[TEXT_BORDER].ti_Tag=GTTX_Border;
  1668.  gad->TagList[TEXT_RECESSED].ti_Tag=GTBB_Recessed;
  1669.  
  1670.  if(!(flags & CTX_NOBORDER)) gad->TagList[TEXT_BORDER].ti_Data=TRUE;
  1671.  if(flags & CGA_RECESSED) gad->TagList[TEXT_RECESSED].ti_Data=TRUE;
  1672.  
  1673.  return(AddMWGadget(gad));
  1674. }
  1675.  
  1676. /* ---- Text-Anzeige abfragen */
  1677. UBYTE *AskTX(gadgetID)
  1678.  ULONG gadgetID;
  1679. {
  1680.  struct MWGadget    *gad;
  1681.  
  1682.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,TEXT_KIND);
  1683.  if(gad)
  1684.    return((WORD)gad->TagList[TEXT_TEXT].ti_Data);
  1685.  return(0L);
  1686. }
  1687.  
  1688. /* ---- Text-Anzeige updaten */
  1689. void UpdateTX(gadgetID,text)
  1690.  ULONG  gadgetID;
  1691.  UBYTE *text;
  1692. {
  1693.  struct MWGadget    *gad;
  1694.  struct WindowEntry *we;
  1695.  
  1696.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,TEXT_KIND);
  1697.  if(gad)
  1698.   {
  1699.    we=gad->WindowEntry;
  1700.    gad->TagList[TEXT_TEXT].ti_Data=text;
  1701.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1702.   }
  1703. }
  1704.  
  1705. /* ---- Zahl-Anzeige hinzufügen */
  1706. BOOL AddNM(gadgetID,helpID,x,y,w,h,textID,flags,number)
  1707.  ULONG          gadgetID;
  1708.  ULONG          helpID;
  1709.  UWORD          x,y,w,h;
  1710.  ULONG          textID;
  1711.  UWORD          flags;
  1712.  LONG           number;
  1713. {
  1714.  struct MWGadget         *gad;
  1715.  struct WindowEntry      *we;
  1716.  struct MultiWindowsUser *mw;
  1717.  struct CycleData        *cd;
  1718.  int                      i;
  1719.  
  1720.  USER;
  1721.  WE;
  1722.  if(we==NULL) return(FALSE);
  1723.  
  1724.  gad=InitGTGadget(gadgetID,helpID,NUMBER_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct CycleData));
  1725.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1726.  
  1727.  gad->TagList[NUMBER_NUMBER].ti_Tag=GTNM_Number;
  1728.  gad->TagList[NUMBER_NUMBER].ti_Data=number;
  1729.  gad->TagList[NUMBER_BORDER].ti_Tag=GTNM_Border;
  1730.  gad->TagList[NUMBER_RECESSED].ti_Tag=GTBB_Recessed;
  1731.  
  1732.  if(!(flags & CNM_NOBORDER)) gad->TagList[NUMBER_BORDER].ti_Data=TRUE;
  1733.  if(flags & CGA_RECESSED) gad->TagList[NUMBER_RECESSED].ti_Data=TRUE;
  1734.  
  1735.  return(AddMWGadget(gad));
  1736. }
  1737.  
  1738. /* ---- Zahl-Anzeige abfragen */
  1739. LONG AskNM(gadgetID)
  1740.  ULONG gadgetID;
  1741. {
  1742.  struct MWGadget    *gad;
  1743.  
  1744.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,NUMBER_KIND);
  1745.  if(gad)
  1746.    return((WORD)gad->TagList[NUMBER_NUMBER].ti_Data);
  1747.  return(0L);
  1748. }
  1749.  
  1750. /* ---- Zahl-Anzeige updaten */
  1751. void UpdateNM(gadgetID,number)
  1752.  ULONG gadgetID;
  1753.  LONG  number;
  1754. {
  1755.  struct MWGadget    *gad;
  1756.  struct WindowEntry *we;
  1757.  
  1758.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,NUMBER_KIND);
  1759.  if(gad)
  1760.   {
  1761.    we=gad->WindowEntry;
  1762.    gad->TagList[NUMBER_NUMBER].ti_Data=number;
  1763.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1764.   }
  1765. }
  1766.  
  1767. /* ---- Zahleneingabe für Float-Zahlen ---------------------------- */
  1768. BOOL AddFloat(gadgetID,helpID,x,y,w,h,textID,flags,number,min,max)
  1769.  ULONG          gadgetID;
  1770.  ULONG          helpID;
  1771.  UWORD          x,y,w,h;
  1772.  ULONG          textID;
  1773.  UWORD          flags;
  1774.  FLOAT          number;
  1775.  FLOAT          min,max;
  1776. {
  1777.  struct StringData       *sd;
  1778.  struct MWGadget         *gad;
  1779.  struct WindowEntry      *we;
  1780.  struct Gadget           *g;
  1781.  struct FloatData        *fd;
  1782.  long                     j;
  1783.  
  1784.  WE;
  1785.  if(we==NULL) return(FALSE);
  1786.  
  1787.  gad=InitGTGadget(gadgetID,helpID,STRING_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct StringData)+sizeof(struct FloatData)+2*22);
  1788.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1789.  
  1790.  sd=gad->ExtData;
  1791.  sd->Hook=&MultiWindowsBase->FloatHook;
  1792.  sd->Special=(ULONG)gad->ExtData+(ULONG)sizeof(struct StringData);
  1793.  sd->Buffer=(ULONG)sd->Special+sizeof(struct FloatData);
  1794.  sd->WorkBuffer=sd->Buffer+22;
  1795.  sd->Flags=flags;
  1796.  sd->SpecialType=SST_FLOAT;
  1797.  
  1798.  fd=sd->Special;
  1799.  fd->Min=min;
  1800.  fd->Max=max;
  1801.  
  1802.  if(number<min) number=min;
  1803.  if(number>max) number=max;
  1804.  sprintf(sd->Buffer,"%f",number);
  1805.  
  1806.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1807.  gad->TagList[STRING_MAXCHARS].ti_Tag=GTST_MaxChars;
  1808.  gad->TagList[STRING_MAXCHARS].ti_Data=20;
  1809.  gad->TagList[STRING_STRING].ti_Tag=GTST_String;
  1810.  gad->TagList[STRING_STRING].ti_Data=sd->Buffer;
  1811.  gad->TagList[STRING_JUSTIFICATION].ti_Tag=STRINGA_Justification;
  1812.  
  1813.  if(flags & CST_CENTER)
  1814.   j=GACT_STRINGCENTER;
  1815.  else if(flags &CST_LEFT)
  1816.   j=GACT_STRINGLEFT;
  1817.  else
  1818.   j=GACT_STRINGRIGHT;
  1819.  gad->TagList[STRING_JUSTIFICATION].ti_Data=j;
  1820.  
  1821.  if(flags & CST_PASSWORD) {
  1822.   if(gad->NewGadget.ng_Height>14)
  1823.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password9Attr;
  1824.    else
  1825.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password5Attr;
  1826.   }
  1827.  
  1828.  return(AddMWGadget(gad));
  1829. }
  1830.  
  1831. /* ---- Zahl des Float-Gadget ermitteln */
  1832. FLOAT AskFloat(gadgetID)
  1833.  ULONG gadgetID;
  1834. {
  1835.  struct MWGadget   *gad;
  1836.  struct StringData *sd;
  1837.  FLOAT              result;
  1838.  
  1839.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1840.  if(gad)
  1841.   {
  1842.    sd=gad->ExtData;
  1843.    if(sd->SpecialType!=SST_FLOAT) return(0.0);
  1844.  
  1845.    sscanf(sd->Buffer,"%f",&result);
  1846.    return(result);
  1847.   }
  1848.  return(0.0);
  1849. }
  1850.  
  1851. /* ---- Zahl des Float-Gadget updaten */
  1852. void UpdateFloat(gadgetID,number)
  1853.  ULONG gadgetID;
  1854.  FLOAT number;
  1855. {
  1856.  struct MWGadget    *gad;
  1857.  struct StringData  *sd;
  1858.  struct FloatData   *fd;
  1859.  struct WindowEntry *we;
  1860.  
  1861.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1862.  if(gad)
  1863.   {
  1864.    we=gad->WindowEntry;
  1865.  
  1866.    sd=gad->ExtData;
  1867.    if(sd->SpecialType!=SST_FLOAT) return;
  1868.  
  1869.    fd=sd->Special;
  1870.    if(fd==NULL) return;
  1871.  
  1872.    if(number<fd->Min) number=fd->Min;
  1873.    if(number>fd->Max) number=fd->Max;
  1874.    sprintf(sd->Buffer,"%f",number);
  1875.  
  1876.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1877.   }
  1878. }
  1879.  
  1880. /* ---- Zahleneingabe für Hex-Zahlen ---------------------------- */
  1881. BOOL AddHex(gadgetID,helpID,x,y,w,h,textID,flags,number,min,max)
  1882.  ULONG          gadgetID;
  1883.  ULONG          helpID;
  1884.  UWORD          x,y,w,h;
  1885.  ULONG          textID;
  1886.  UWORD          flags;
  1887.  ULONG          number;
  1888.  ULONG          min,max;
  1889. {
  1890.  struct StringData       *sd;
  1891.  struct HexData          *hd;
  1892.  struct MWGadget         *gad;
  1893.  struct WindowEntry      *we;
  1894.  struct Gadget           *g;
  1895.  long                     j;
  1896.  
  1897.  WE;
  1898.  if(we==NULL) return(FALSE);
  1899.  
  1900.  gad=InitGTGadget(gadgetID,helpID,STRING_KIND,x,y,w,h,textID,PlaceText(flags,PLACETEXT_ABOVE),sizeof(struct StringData)+sizeof(struct HexData)+2*10);
  1901.  if(gad==NULL) { NoMemory(); return(FALSE); }
  1902.  
  1903.  sd=gad->ExtData;
  1904.  sd->Hook=&MultiWindowsBase->HexHook;
  1905.  sd->Special=(ULONG)gad->ExtData+(ULONG)sizeof(struct StringData);
  1906.  sd->Buffer=(ULONG)sd->Special+sizeof(struct HexData);
  1907.  sd->WorkBuffer=sd->Buffer+10;
  1908.  sd->Flags=flags;
  1909.  sd->SpecialType=SST_HEX;
  1910.  
  1911.  hd=sd->Special;
  1912.  hd->Min=min;
  1913.  hd->Max=max;
  1914.  
  1915.  if(number<min) number=min;
  1916.  if(number>max) number=max;
  1917.  sprintf(sd->Buffer,"%lx",number);
  1918.  
  1919.  if(flags & CGA_DISABLE) gad->TagList[GADGET_DISABLE].ti_Data=TRUE;
  1920.  gad->TagList[STRING_MAXCHARS].ti_Tag=GTST_MaxChars;
  1921.  gad->TagList[STRING_MAXCHARS].ti_Data=8;
  1922.  gad->TagList[STRING_STRING].ti_Tag=GTST_String;
  1923.  gad->TagList[STRING_STRING].ti_Data=sd->Buffer;
  1924.  gad->TagList[STRING_JUSTIFICATION].ti_Tag=STRINGA_Justification;
  1925.  
  1926.  if(flags & CST_CENTER)
  1927.   j=GACT_STRINGCENTER;
  1928.  else if(flags &CST_LEFT)
  1929.   j=GACT_STRINGLEFT;
  1930.  else
  1931.   j=GACT_STRINGRIGHT;
  1932.  gad->TagList[STRING_JUSTIFICATION].ti_Data=j;
  1933.  
  1934.  if(flags & CST_PASSWORD) {
  1935.   if(gad->NewGadget.ng_Height>14)
  1936.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password9Attr;
  1937.    else
  1938.      gad->NewGadget.ng_TextAttr=MultiWindowsBase->Password5Attr;
  1939.   }
  1940.  
  1941.  return(AddMWGadget(gad));
  1942. }
  1943.  
  1944. /* ---- Zahl des Hex-Gadget ermitteln */
  1945. ULONG AskHex(gadgetID)
  1946.  ULONG gadgetID;
  1947. {
  1948.  struct MWGadget   *gad;
  1949.  struct StringData *sd;
  1950.  ULONG              result;
  1951.  
  1952.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1953.  if(gad)
  1954.   {
  1955.    sd=gad->ExtData;
  1956.    if(sd->SpecialType!=SST_HEX) return(0);
  1957.  
  1958.    sscanf(sd->Buffer,"%lx",&result);
  1959.    return(result);
  1960.   }
  1961.  return(0);
  1962. }
  1963.  
  1964. /* ---- Zahl des Hex-Gadget updaten */
  1965. void UpdateHex(gadgetID,number)
  1966.  ULONG gadgetID;
  1967.  ULONG number;
  1968. {
  1969.  struct MWGadget    *gad;
  1970.  struct WindowEntry *we;
  1971.  struct StringData  *sd;
  1972.  struct HexData     *hd;
  1973.  
  1974.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,STRING_KIND);
  1975.  if(gad)
  1976.   {
  1977.    we=gad->WindowEntry;
  1978.  
  1979.    sd=gad->ExtData;
  1980.    if(sd->SpecialType!=SST_HEX) return;
  1981.  
  1982.    hd=sd->Special;
  1983.    if(hd==NULL) return;
  1984.  
  1985.    if(number<hd->Min) number=hd->Min;
  1986.    if(number>hd->Max) number=hd->Max;
  1987.    sprintf(sd->Buffer,"%lx",number);
  1988.  
  1989.    if(!we->Iconify) GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  1990.   }
  1991. }
  1992.  
  1993. /* ---- Hook für Float-Gadgets */
  1994. ULONG FloatHookProc(hook,sg,msg)
  1995.  struct Hook   *hook;
  1996.  struct SGWork *sg;
  1997.  ULONG         *msg;
  1998. {
  1999.  int i,found;
  2000.  
  2001.  if(*msg==SGH_KEY)
  2002.   {
  2003.    if((sg->EditOp==EO_REPLACECHAR)||(sg->EditOp==EO_INSERTCHAR))
  2004.     {
  2005.      if(!( ((sg->Code>='0') && (sg->Code<='9')) || (sg->Code=='-') || (sg->Code=='.') || (sg->Code=='+') ))
  2006.       {
  2007.        sg->Actions |= SGA_BEEP;
  2008.        sg->Actions &= ~SGA_USE;
  2009.        return(~0);
  2010.       }
  2011.      if((sg->Code=='-')||(sg->Code=='+'))
  2012.       {
  2013.        if(sg->BufferPos!=1)
  2014.         {
  2015.          sg->Actions |= SGA_BEEP;
  2016.          sg->Actions &= ~SGA_USE;
  2017.          return(~0);
  2018.         }
  2019.       }
  2020.      if(sg->Code=='.')
  2021.       {
  2022.        found=0;
  2023.        for(i=0;i<sg->NumChars;i++)
  2024.         {
  2025.          if(sg->WorkBuffer[i]=='.')
  2026.           {
  2027.            found++;
  2028.            if(found>1)
  2029.             {
  2030.              sg->Actions |= SGA_BEEP;
  2031.              sg->Actions &= ~SGA_USE;
  2032.              return(~0);
  2033.             }
  2034.           }
  2035.         }
  2036.       }
  2037.     }
  2038.   }
  2039.  return(0L);
  2040. }
  2041.  
  2042. /* ---- Hook für Hex-Gadgets */
  2043. ULONG HexHookProc(hook,sg,msg)
  2044.  struct Hook   *hook;
  2045.  struct SGWork *sg;
  2046.  ULONG         *msg;
  2047. {
  2048.  UBYTE              code;
  2049.  struct MWGadget   *gad;
  2050.  struct StringData *sd;
  2051.  
  2052.  if(*msg==SGH_KEY)
  2053.   {
  2054.    code=toupper(sg->Code);
  2055.    if((sg->EditOp==EO_REPLACECHAR)||(sg->EditOp==EO_INSERTCHAR))
  2056.     {
  2057.      if(!( ((code>='0') && (code<='9')) ||
  2058.            ((code>='A') && (code<='F')) ))
  2059.       {
  2060.        sg->Actions |= SGA_BEEP;
  2061.        sg->Actions &= ~SGA_USE;
  2062.        return(~0);
  2063.       }
  2064.      else
  2065.       {
  2066.        gad=sg->Gadget->UserData;
  2067.        sd=gad->ExtData;
  2068.        if(sd->Flags & CHX_TOUPPER)
  2069.          sg->WorkBuffer[sg->BufferPos-1]=code;
  2070.        else if(sd->Flags & CHX_TOLOWER)
  2071.          sg->WorkBuffer[sg->BufferPos-1]=tolower(code);
  2072.       }
  2073.     }
  2074.   }
  2075.  return(0L);
  2076. }
  2077.  
  2078. /* ---- Hook für UserHook-Gadgets */
  2079. ULONG UserHookProc(hook,sg,msg)
  2080.  struct Hook   *hook;
  2081.  struct SGWork *sg;
  2082.  ULONG         *msg;
  2083. {
  2084.  BOOL               found;
  2085.  UBYTE              code;
  2086.  LONG               res;
  2087.  struct MWGadget   *gad;
  2088.  struct StringData *sd;
  2089.  struct StringHook *sh;
  2090.  int                i;
  2091.  
  2092.  gad=sg->Gadget->UserData;
  2093.  sd=gad->ExtData;
  2094.  sh=sd->Special;
  2095.  
  2096.  if(*msg==SGH_KEY)
  2097.   {
  2098.    code=sg->Code;
  2099.    if((sg->EditOp==EO_REPLACECHAR)||(sg->EditOp==EO_INSERTCHAR))
  2100.     {
  2101.      if(sh->Flags & SHF_USERROUTINE)
  2102.       {
  2103.        res=sh->UserRoutine(sh->UserData,sg,msg);
  2104.        if(res==URR_RETURN) return(~0);
  2105.        if(res==URR_OKAY) return(0L);
  2106.       }
  2107.  
  2108.      if(sh->Flags & SHF_TOUPPER) code=toupper(code);
  2109.      if(sh->Flags & SHF_TOLOWER) code=tolower(code);
  2110.  
  2111.      if(sh->Flags & SHF_CHARTABLE)
  2112.       {
  2113.        i=0; found=FALSE;
  2114.        while((sh->CharTable[i]!=0x00)&&(i<256))
  2115.         {
  2116.          if(sh->CharTable[i]==code)
  2117.           {
  2118.            found=TRUE;
  2119.            break;
  2120.           }
  2121.          i++;
  2122.         }
  2123.        if(found==FALSE)
  2124.         {
  2125.          sg->Actions |= SGA_BEEP;
  2126.          sg->Actions &= ~SGA_USE;
  2127.          return(~0);
  2128.         }
  2129.       }
  2130.  
  2131.      sg->WorkBuffer[sg->BufferPos-1]=code;
  2132.     }
  2133.   }
  2134.  return(0L);
  2135. }
  2136.  
  2137. /* ---- Hook in Gadget->StringInfo->Extension schreiben */
  2138. void AddHook(gad)
  2139.  struct MWGadget *gad;
  2140. {
  2141.  struct StringData   *sd;
  2142.  struct StringInfo   *si;
  2143.  struct StringExtend *se;
  2144.  
  2145.  si=gad->Update->SpecialInfo;
  2146.  se=si->Extension;
  2147.  sd=gad->ExtData;
  2148.  if(sd->WorkBuffer==NULL) return;   /* Normales String-Gadget -> Ende */
  2149.  
  2150.  se->EditHook=sd->Hook;
  2151.  se->WorkBuffer=sd->Buffer;
  2152. }
  2153.  
  2154.  
  2155. /* ---- Eintrag im Listview-Gadget updaten */
  2156. void ChangeListviewEntryNumber(gadgetID,num,label)
  2157.  ULONG  gadgetID;
  2158.  ULONG  num;
  2159.  UBYTE *label;
  2160. {
  2161.  struct TagItem       tag[2];
  2162.  struct MWGadget     *gad;
  2163.  struct WindowEntry  *we;
  2164.  struct ListviewData *ld;
  2165.  struct ListviewNode *ln,*new;
  2166.  struct Node         *pred;
  2167.  int                  j;
  2168.  
  2169.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  2170.  if(gad)
  2171.   {
  2172.    we=gad->WindowEntry;
  2173.  
  2174.    ld=gad->ExtData;
  2175.    ln=FindNode(&ld->List,num);
  2176.    if(ln==NULL) return;
  2177.  
  2178.    pred=ln->Node.ln_Pred;
  2179.    Remove(ln);
  2180.  
  2181.    j=strlen(label)+1;
  2182.    new=AllocMemory(&ld->Remember,sizeof(struct ListviewNode)+j,MEMF_PUBLIC);
  2183.    if(new==NULL) { NoMemory(); return; }
  2184.    new->Node.ln_Pred=NULL;
  2185.    new->Node.ln_Succ=NULL;
  2186.    new->Node.ln_Type=0;
  2187.    new->Node.ln_Pri=0;
  2188.    new->Node.ln_Name=&new->Label;
  2189.    CopyMem(label,&new->Label,j);
  2190.  
  2191.    Insert(&ld->List,new,pred);
  2192.    FreeMemoryBlock(&ld->Remember,ln);
  2193.  
  2194.    if(!we->Iconify)
  2195.     {
  2196.      tag[0].ti_Tag=GTLV_Labels;
  2197.      tag[0].ti_Data=&ld->List;
  2198.      tag[1].ti_Tag=TAG_DONE;
  2199.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  2200.     }
  2201.   }
  2202. }
  2203.  
  2204. /* ---- Aktuellen Eintrag im Listview-Gadget updaten */
  2205. void ChangeListviewEntrySelected(gadgetID,label)
  2206.  ULONG  gadgetID;
  2207.  UBYTE *label;
  2208. {
  2209.  LONG i;
  2210.  
  2211.  i=AskListviewSelection(gadgetID);
  2212.  if(i>=0)
  2213.    ChangeListviewEntryNumber(gadgetID,label,i);
  2214. }
  2215.  
  2216. /* ---- Einträge im Listview-Gadget updaten */
  2217. void SetListviewList(gadgetID,list)
  2218.  ULONG         gadgetID;
  2219.  struct List *list;
  2220. {
  2221.  struct TagItem       tag[3];
  2222.  struct WindowEntry  *we;
  2223.  struct MWGadget     *gad;
  2224.  struct ListviewData *ld;
  2225.  struct Node         *node;
  2226.  
  2227.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  2228.  if(gad)
  2229.   {
  2230.    we=gad->WindowEntry;
  2231.  
  2232.    ld=gad->ExtData;
  2233.    FreeMemory(&ld->Remember);
  2234.    NewList(&ld->List);
  2235.  
  2236.    for(node=list->lh_Head;node!=&list->lh_Tail;node=node->ln_Succ)
  2237.      AddListviewEntrySort(gad->GadgetID,node->ln_Name,ULP_TAIL);
  2238.  
  2239.    if(!we->Iconify)
  2240.     {
  2241.      tag[0].ti_Tag=GTLV_Labels;
  2242.      tag[0].ti_Data=&ld->List;
  2243.      tag[1].ti_Tag=GTLV_Selected;
  2244.      tag[1].ti_Data=-1L;
  2245.      tag[2].ti_Tag=TAG_DONE;
  2246.      GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&tag);
  2247.     }
  2248.  
  2249.    CallAction(gad);
  2250.   }
  2251. }
  2252.  
  2253. /* ---- Einträge im Listview-Gadget als Liste zurückliefern */
  2254. struct List *GetListviewList(gadgetID)
  2255.  ULONG         gadgetID;
  2256. {
  2257.  struct MWGadget     *gad;
  2258.  struct ListviewData *ld;
  2259.  
  2260.  gad=GetGadget(gadgetID,MWGAD_GADTOOLS,LISTVIEW_KIND);
  2261.  if(gad)
  2262.   {
  2263.    ld=gad->ExtData;
  2264.    return(&ld->List);
  2265.   }
  2266.  return(NULL);
  2267. }
  2268.